#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include "db.hpp"
#include "util.hpp"
#include "session.hpp"
#include "room.hpp"
#include "matcher.hpp"
#include "online.hpp"

#define WWWROOT "./wwwroot/"

class gobang_server
{
private:
    //http响应信息的封装
    void http_resp(wsserver_t::connection_ptr &conn, bool result, websocketpp::http::status_code::value code, const std::string &reason)
    {
        Json::Value json_resp;
        json_resp["result"] = result;
        json_resp["reason"] = reason;
        std::string resp_body;
        json_util::serialize(json_resp, resp_body);
        conn->set_status(code);//设置响应状态码
        conn->set_body(resp_body);//设置http响应正文
        conn->append_header("Content-type", "application/json");//添加http响应头部字段
        return;
    }

    //用户注册请求处理
    void reg(wsserver_t::connection_ptr &conn)
    {
        //获取请求对象
        websocketpp::http::parser::request req = conn->get_request();
        //获取请求正文
        std::string req_body = conn->get_request_body();
        //反序列化
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if (ret == false)
        {
            DLOG("反序列化注册信息失败！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误！");
        }

        //进行数据库的用户新增操作
        if (login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名密码不完整！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码！");
        }
        ret = _ut.insert(login_info);
        if (ret == false)
        {
            DLOG("向数据库插入数据失败！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名已经被占用！");
        }

        return http_resp(conn, true, websocketpp::http::status_code::ok, "注册用户成功！");
    }


    //用户登录请求处理
    void login(wsserver_t::connection_ptr &conn)
    {
        //获取请求正文，并且反序列化
        std::string req_body = conn->get_request_body();
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误！");
        }

        //校验正文完整性，进行数据库的用户信息验证
        if (login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名/密码不完整！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码！");
        }
        ret = _ut.login(login_info);
        if (ret == false)
        {
            DLOG("用户名/密码错误！");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名/密码错误！");
        }

        //给客户端创建session
        uint64_t uid = login_info["id"].asUInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if (ssp.get() == nullptr)
        {
            DLOG("创建会话失败！");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败！");
        }
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);//会话创建成功后设置一个定时器

        //设置响应头部
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功！");
    }

    //通过Cookie提取ssid
    bool get_cookie_val(const std::string &cookie_str, const std::string &key, std::string &val)
    {
        //Cookie: SSID=XXXX; path=/;
        //以 ; 为间隔，对字符串进行分割
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str, sep, cookie_arr);
        //对单个cookie字符串，以 = 为间隔进行分割，得到key和val
        for (auto str : cookie_arr)
        {
            std::vector<std::string> tmp_arr;
            string_util::split(str, "=", tmp_arr);
            if (tmp_arr.size() != 2) { continue; }
            if (tmp_arr[0] == key)
            {
                val = tmp_arr[1];
                return true;
            }
        }
        return false;
    }

    //用户信息获取功能请求的处理
    void info(wsserver_t::connection_ptr &conn)
    {
        Json::Value err_resp;
        //获取请求信息中的Cookie，从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录！");
        }
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登录！");
        }

        //在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "登录过期，请重新登录！");
        }

        //从数据库中取出用户信息，序列化后发给客户端
        uint64_t uid = ssp->get_user();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if (ret == false)
        {
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到用户，请重新登录！");
        }
        std::string body;
        json_util::serialize(user_info, body);
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
        conn->append_header("Content-Type", "application/json");
        
        //刷新session的过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        
    }

    //静态资源请求的处理
    void file_handler(wsserver_t::connection_ptr &conn)
    {
        //获取请求uri资源路径
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        //组合出文件的实际路径-->相对根目录 + uri
        std::string realpath = _web_root + uri;
        //如果请求的是个目录，增加一个后缀login.html,      / -> /login.html
        if (realpath.back() == '/') realpath += "login.html";

        //读取文件内容
        Json::Value resp_json;
        std::string body;
        bool ret = file_util::read(realpath, body);
        if (ret == false)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            conn->set_body(body);
            conn->set_status(websocketpp::http::status_code::not_found);
            return;
        }

        //设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);

    }

    //http请求回调处理函数
    void http_callback(websocketpp::connection_hdl hdl)
    {
        //获取connection_hdl对应连接的connection_ptr
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        //获取http请求对象
        websocketpp::http::parser::request req = conn->get_request();
        //获取请求方法
        std::string method = req.get_method();
        //获取uri接口
        std::string uri = req.get_uri();

        if (method == "POST" && uri == "/reg") return reg(conn);
        else if (method == "POST" && uri == "/login") return login(conn);
        else if (method == "GET" && uri == "/info") return info(conn);
        else return file_handler(conn);
    }

    //websocket响应
    void ws_resp(wsserver_t::connection_ptr conn, Json::Value &resp)
    {
        std::string body;
        json_util::serialize(resp, body);
        conn->send(body);
    }
    
    //通过cookie获取session
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
    {
        Json::Value err_resp;
        //获取cookie
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            err_resp["optype"] = "hall_ready";
            err_resp["result"] = false; 
            err_resp["reason"] = "没有找到cookie信息，需要重新登录！";
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        //获取cookie中的ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            err_resp["optyep"] = "hall_ready";
            err_resp["resule"] = false;
            err_resp["reason"] = "没有找到SSID信息，需要重新登录！";
            ws_resp(conn, err_resp);
            return session_ptr();
        }

        //在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            err_resp["optype"] = "hall_ready";
            err_resp["result"] = false;
            err_resp["reason"] = "没有找到session信息，需要重新登录！";
            ws_resp(conn, err_resp);
            return session_ptr();            
        }
        return ssp;

    }

    //游戏大厅长连接建立
    void wsopen_game_hall(wsserver_t::connection_ptr conn)
    {
        Json::Value json_resp;
        //判断当前客户端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) return;

        //判断当前客户端是否是重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            json_resp["optype"] = "hall_ready";
            json_resp["result"] = false;
            json_resp["reason"] = "玩家重复登录！";
            return ws_resp(conn, json_resp);
        }

        //将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user(), conn);
        //给客户端响应游戏大厅连接建立成功
        json_resp["optype"] = "hall_ready";
        json_resp["result"] = true;
        ws_resp(conn, json_resp);
        //将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }

    //游戏房间长连接建立
    void wsopen_game_room(wsserver_t::connection_ptr conn)
    {
        Json::Value json_resp;
        //获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) return;
        //判断当前客户端是否是重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            json_resp["optype"] = "room_ready";
            json_resp["result"] = false;
            json_resp["reason"] = "玩家重复登录！";
            return ws_resp(conn, json_resp);
        }
        //判断当前用户是否已经创建好了房间
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            json_resp["optype"] = "room_ready";
            json_resp["result"] = false;
            json_resp["reason"] = "没有找到玩家的房间信息！";
            return ws_resp(conn, json_resp);
        }
        //将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), conn);
        //将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        //回复房间准备完毕
        json_resp["optype"] = "room_ready";
        json_resp["result"] = true;
        json_resp["room_id"] = (Json::UInt64)rp->id();
        json_resp["uid"] = (Json::UInt64)ssp->get_user();
        json_resp["white_id"] = (Json::UInt64)rp->get_white_user();
        json_resp["black_id"] = (Json::UInt64)rp->get_black_user();
        return ws_resp(conn, json_resp);
    }

    //websocket长连接建立成功之后的处理函数
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall") return wsopen_game_hall(conn);
        else if (uri == "/room") return wsopen_game_room(conn);

    }

    //游戏大厅长连接断开的处理
    void wsclose_game_hall(wsserver_t::connection_ptr conn)
    {
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) return;

        //将玩家从大厅中移除
        _om.exit_game_hall(ssp->get_user());
        //设置session的定时器
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    //游戏房间长连接断开的处理
    void wsclose_game_room(wsserver_t::connection_ptr conn)
    {
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) return;

        //将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        //设置session的定时器
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        //将玩家从游戏房间中移除,
        _rm.remove_room_user(ssp->get_user());
    }

    //websocket连接断开前的处理
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            return wsclose_game_hall(conn);
        }else if (uri == "/room")
        {
            return wsclose_game_room(conn);
        }
    }

    //在游戏大厅中开始进行匹配对战
    void wsmsg_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value json_resp;
        std::string resp_body;

        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) return;

        //获取请求信息
        std::string req_body = msg->get_payload();//这个函数是获取消息的消息体
        Json::Value json_req;
        bool ret = json_util::unserialize(req_body, json_req);
        if (ret == false)
        {
            json_resp["result"] = false;
            json_resp["reason"] = "请求信息解析失败！";
            return ws_resp(conn, json_resp);
        }

        //对请求信息进行处理
        //开始匹配，将用户添加到匹配队列中
        if (!json_req["optype"].isNull() && json_req["optype"].asString() == "match_start")
        {
            _mm.add(ssp->get_user());
            json_resp["optype"] = "match_start";
            json_resp["result"] = true;
            return ws_resp(conn, json_resp);
        }
        else if (!json_req["optype"].isNull() && json_req["optype"].asString() == "match_stop")
        {
            //停止匹配，将用户从匹配队列中移除
            _mm.del(ssp->get_user());
            json_resp["optype"] = "match_stop";
            json_resp["result"] = true;
            return ws_resp(conn, json_resp);
        }
        json_resp["optype"] = "unknow";
        json_resp["resutl"] = false;
        json_resp["reason"] = "未知请求类型！";
        return ws_resp(conn, json_resp);
    }

    //游戏房间中进行下棋或聊天
    void wsmsg_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value json_resp;
        //获取客户端session
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr) 
        {
            DLOG("房间：没有找到会话信息！");
            return;
        }
        //获取客户端房间信息
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            json_resp["optype"] = "unknow";
            json_resp["result"] = false;
            json_resp["reason"] = "没有找到玩家的房间信息！";
            DLOG("房间：没有找到玩家的房间信息！");
            return ws_resp(conn, json_resp);
        }

        //对消息进行反序列化
        Json::Value json_req;
        std::string req_body = msg->get_payload();
        bool ret = json_util::unserialize(req_body, json_req);
        if (ret == false)
        {
            json_resp["optype"] = "unknow";
            json_resp["result"] = false;
            json_resp["reason"] = "请求解析失败！";
            DLOG("房间：反序列化请求失败！");
            return ws_resp(conn, json_resp);

        }
        DLOG("房间：收到房间请求，开始处理......");
        return rp->handle_request(json_req);
    }

    //websocket长连接通信处理
    void wsmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            //建立了游戏大厅的长连接
            return wsmsg_game_hall(conn, msg);
        }
        else if (uri == "/room")
        {
            //建立了游戏房间的长连接
            return wsmsg_game_room(conn, msg);
        }
    }

public:
    gobang_server(const std::string &host, const std::string &user, const std::string &pass
        , const std::string &dbname, uint16_t port=3306, const std::string &wwwroot=WWWROOT)
            : _web_root(wwwroot), _ut(host, user, pass, dbname, port)
            , _rm(&_ut, &_om), _sm(&_wssrv), _mm(&_rm, &_ut, &_om)
    {
        //设置日志级别
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        //初始化asio相关资源
        _wssrv.init_asio();
        //启用地址重用
        _wssrv.set_reuse_addr(true);//允许服务器在关闭后能够快速地重新绑定到相同的地址和端口上
        //设置回调函数
        //http请求回调处理函数
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        //websocket握手成功回调处理函数
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        //websocket连接关闭回调处理函数
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        //websocket消息回调处理函数
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2));
    }

    //启动服务器
    void start(int port)
    {
        _wssrv.listen(port);//设置监听端口
        _wssrv.start_accept();//开始获取新连接
        _wssrv.run();//启动服务器
    }


private:
    std::string _web_root;//静态资源根目录
    wsserver_t _wssrv;
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manage _sm;
    matcher _mm;
};
#endif